| GCC Code Coverage Report | |||||||||||||||||||||
|
|||||||||||||||||||||
| Line | Branch | Exec | Source |
1 |
#include <string> |
||
2 |
#include <functional> |
||
3 |
#include <type_traits> |
||
4 |
|||
5 |
#include "gtest/gtest.h" |
||
6 |
|||
7 |
#include "zserio/ArrayTraits.h" |
||
8 |
#include "zserio/BitStreamReader.h" |
||
9 |
#include "zserio/BitStreamWriter.h" |
||
10 |
#include "zserio/BitSizeOfCalculator.h" |
||
11 |
#include "zserio/Reflectable.h" |
||
12 |
#include "zserio/Vector.h" |
||
13 |
|||
14 |
#include "test_object/std_allocator/ReflectableBitmask.h" |
||
15 |
#include "test_object/std_allocator/ReflectableEnum.h" |
||
16 |
#include "test_object/std_allocator/ReflectableNested.h" |
||
17 |
#include "test_object/std_allocator/ReflectableObject.h" |
||
18 |
|||
19 |
using test_object::std_allocator::ReflectableBitmask; |
||
20 |
using test_object::std_allocator::ReflectableEnum; |
||
21 |
using test_object::std_allocator::ReflectableNested; |
||
22 |
using test_object::std_allocator::ReflectableObject; |
||
23 |
|||
24 |
using namespace std::placeholders; |
||
25 |
|||
26 |
namespace zserio |
||
27 |
{ |
||
28 |
|||
29 |
namespace |
||
30 |
{ |
||
31 |
|||
32 |
5 |
ReflectableObject createInitializedReflectableObject(const string<>& stringField, |
|
33 |
uint32_t reflectableNestedValue) |
||
34 |
{ |
||
35 |
✓✗ | 5 |
ReflectableObject reflectableObject(stringField, ReflectableNested{reflectableNestedValue}); |
36 |
✓✗ | 5 |
reflectableObject.initializeChildren(); |
37 |
5 |
return reflectableObject; |
|
38 |
} |
||
39 |
|||
40 |
} // namespace |
||
41 |
|||
42 |
✗✓ | 122 |
class ReflectableTest : public ::testing::Test |
43 |
{ |
||
44 |
protected: |
||
45 |
template <typename RAW_ARRAY, typename REFLECTABLE_PTR, typename ELEMENT_CHECKER> |
||
46 |
22 |
void checkArray(const RAW_ARRAY& rawArray, const REFLECTABLE_PTR& reflectable, |
|
47 |
const ELEMENT_CHECKER& elementChecker) |
||
48 |
{ |
||
49 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ |
22 |
ASSERT_TRUE(reflectable->isArray()); |
50 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
22 |
ASSERT_EQ(rawArray.size(), reflectable->size()); |
51 |
✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ |
90 |
for (size_t i = 0; i < rawArray.size(); ++i) |
52 |
{ |
||
53 |
✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ |
68 |
if (i % 2 == 0) |
54 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ |
40 |
elementChecker(rawArray[i], reflectable->at(i)); |
55 |
else |
||
56 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗ |
28 |
elementChecker(rawArray[i], (*reflectable)[i]); |
57 |
} |
||
58 |
|||
59 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
44 |
ASSERT_THROW(reflectable->at(rawArray.size()), CppRuntimeException); |
60 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
44 |
ASSERT_THROW((*reflectable)[rawArray.size()], CppRuntimeException); |
61 |
|||
62 |
using ReflectableType = typename REFLECTABLE_PTR::element_type; |
||
63 |
if (std::is_const<ReflectableType>::value) |
||
64 |
{ |
||
65 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗ |
14 |
ASSERT_EQ(rawArray, |
66 |
reflectable->getAnyValue().template get<std::reference_wrapper<const RAW_ARRAY>>().get()); |
||
67 |
} |
||
68 |
else |
||
69 |
{ |
||
70 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✓ ✗✓✗✗ |
8 |
ASSERT_EQ(rawArray, |
71 |
reflectable->getAnyValue().template get<std::reference_wrapper<RAW_ARRAY>>().get()); |
||
72 |
} |
||
73 |
|||
74 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
44 |
ASSERT_THROW(reflectable->getBool(), CppRuntimeException); |
75 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
44 |
ASSERT_THROW(reflectable->getInt8(), CppRuntimeException); |
76 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
44 |
ASSERT_THROW(reflectable->getInt16(), CppRuntimeException); |
77 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
44 |
ASSERT_THROW(reflectable->getInt32(), CppRuntimeException); |
78 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
44 |
ASSERT_THROW(reflectable->getInt64(), CppRuntimeException); |
79 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
44 |
ASSERT_THROW(reflectable->getUInt8(), CppRuntimeException); |
80 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
44 |
ASSERT_THROW(reflectable->getUInt16(), CppRuntimeException); |
81 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
44 |
ASSERT_THROW(reflectable->getUInt32(), CppRuntimeException); |
82 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
44 |
ASSERT_THROW(reflectable->getUInt64(), CppRuntimeException); |
83 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
44 |
ASSERT_THROW(reflectable->getFloat(), CppRuntimeException); |
84 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
44 |
ASSERT_THROW(reflectable->getDouble(), CppRuntimeException); |
85 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
44 |
ASSERT_THROW(reflectable->getBytes(), CppRuntimeException); |
86 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
44 |
ASSERT_THROW(reflectable->getStringView(), CppRuntimeException); |
87 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
44 |
ASSERT_THROW(reflectable->getBitBuffer(), CppRuntimeException); |
88 |
|||
89 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
44 |
ASSERT_THROW(reflectable->toInt(), CppRuntimeException); |
90 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
44 |
ASSERT_THROW(reflectable->toUInt(), CppRuntimeException); |
91 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
44 |
ASSERT_THROW(reflectable->toDouble(), CppRuntimeException); |
92 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
44 |
ASSERT_THROW(reflectable->toString(), CppRuntimeException); |
93 |
|||
94 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
44 |
ASSERT_THROW(reflectable->bitSizeOf(0), CppRuntimeException); |
95 |
|||
96 |
✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗✓ ✗✓✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗✓ ✗✓✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗✓ ✗✓✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗✓ ✗✓✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗✓ ✗✓✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗ |
44 |
BitBuffer bitBuffer(0); |
97 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ |
22 |
BitStreamWriter writer(bitBuffer); |
98 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
44 |
ASSERT_THROW(reflectable->write(writer), CppRuntimeException); |
99 |
|||
100 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ |
22 |
checkNonCompound(reflectable); |
101 |
} |
||
102 |
|||
103 |
template <typename T, typename REFLECTABLE_PTR, typename READ_FUNC> |
||
104 |
117 |
void checkWriteRead(T value, const REFLECTABLE_PTR& reflectable, const READ_FUNC& readFunc, |
|
105 |
size_t bitBufferSize) |
||
106 |
{ |
||
107 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗ |
234 |
BitBuffer bitBuffer(bitBufferSize); |
108 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗ |
117 |
BitStreamWriter writer(bitBuffer); |
109 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗ |
117 |
reflectable->write(writer); |
110 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗ |
117 |
const size_t bitSizeOfValue = reflectable->bitSizeOf(); |
111 |
✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
117 |
ASSERT_EQ(bitSizeOfValue, writer.getBitPosition()); |
112 |
|||
113 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗ |
117 |
BitStreamReader reader(bitBuffer); |
114 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
117 |
ASSERT_EQ(value, readFunc(reader)); |
115 |
✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗ |
117 |
ASSERT_EQ(bitSizeOfValue, reader.getBitPosition()); |
116 |
} |
||
117 |
|||
118 |
117 |
void checkNonArray(const IReflectableConstPtr& reflectable) |
|
119 |
{ |
||
120 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗ |
117 |
ASSERT_FALSE(reflectable->isArray()); |
121 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
234 |
ASSERT_THROW(reflectable->size(), CppRuntimeException); |
122 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
234 |
ASSERT_THROW(reflectable->at(0), CppRuntimeException); |
123 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
234 |
ASSERT_THROW((*reflectable)[0], CppRuntimeException); |
124 |
} |
||
125 |
|||
126 |
69 |
void checkNonArray(const IReflectablePtr& reflectable) |
|
127 |
{ |
||
128 |
✓✗✓✗ ✗ |
69 |
checkNonArray(static_cast<IReflectableConstPtr>(reflectable)); |
129 |
|||
130 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
138 |
ASSERT_THROW(reflectable->at(0), CppRuntimeException); |
131 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
138 |
ASSERT_THROW((*reflectable)[0], CppRuntimeException); |
132 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
138 |
ASSERT_THROW(reflectable->resize(1), CppRuntimeException); |
133 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
138 |
ASSERT_THROW(reflectable->setAt(AnyHolder<>(), 0), CppRuntimeException); |
134 |
} |
||
135 |
|||
136 |
template <typename REFLECTABLE_PTR> |
||
137 |
128 |
void checkNonCompoundConstMethods(const REFLECTABLE_PTR& reflectable) |
|
138 |
{ |
||
139 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
256 |
ASSERT_THROW(reflectable->getField("field"), CppRuntimeException); |
140 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
256 |
ASSERT_THROW(reflectable->getParameter("parameter"), CppRuntimeException); |
141 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ |
256 |
ASSERT_THROW(reflectable->callFunction("function"), CppRuntimeException); |
142 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
256 |
ASSERT_THROW(reflectable->getChoice(), CppRuntimeException); |
143 |
|||
144 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
128 |
ASSERT_EQ(nullptr, reflectable->find("some.field")); |
145 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
128 |
ASSERT_EQ(nullptr, (*reflectable)["some.field"]); |
146 |
} |
||
147 |
|||
148 |
74 |
void checkNonCompound(const IReflectablePtr& reflectable) |
|
149 |
{ |
||
150 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
148 |
ASSERT_THROW(reflectable->initializeChildren(), CppRuntimeException); |
151 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
148 |
ASSERT_THROW(reflectable->initialize(vector<AnyHolder<>>()), CppRuntimeException); |
152 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
148 |
ASSERT_THROW(reflectable->setField("field", AnyHolder<>{}), CppRuntimeException); |
153 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ |
148 |
ASSERT_THROW(reflectable->createField("field"), CppRuntimeException); |
154 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
148 |
ASSERT_THROW(reflectable->initializeOffsets(), CppRuntimeException); |
155 |
|||
156 |
✓✗✗ | 74 |
checkNonCompoundConstMethods(reflectable); |
157 |
} |
||
158 |
|||
159 |
54 |
void checkNonCompound(const IReflectableConstPtr& reflectable) |
|
160 |
{ |
||
161 |
54 |
checkNonCompoundConstMethods(reflectable); |
|
162 |
54 |
} |
|
163 |
|||
164 |
template <typename T, typename REFLECTABLE_PTR, typename GETTER> |
||
165 |
280 |
void checkArithmeticCppTypeGetter(T value, const REFLECTABLE_PTR& reflectable, |
|
166 |
CppType cppType, const GETTER& getter, bool& match) |
||
167 |
{ |
||
168 |
✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✓✗✗✗ ✗✗✗✓ ✗✓✗✓ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✓✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✓ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✓✗ |
280 |
if (reflectable->getTypeInfo().getCppType() == cppType) |
169 |
{ |
||
170 |
✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✓ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✓ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✓ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✓ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✓✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✓✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✓✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✓ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✓ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✗✗ ✗ |
64 |
ASSERT_EQ(value, ((*reflectable).*getter)()); |
171 |
64 |
match = true; |
|
172 |
} |
||
173 |
else |
||
174 |
{ |
||
175 |
✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
432 |
ASSERT_THROW(((*reflectable).*getter)(), CppRuntimeException); |
176 |
} |
||
177 |
} |
||
178 |
|||
179 |
template <typename T, typename REFLECTABLE_PTR> |
||
180 |
64 |
void checkArithmeticCppTypeGetters(T value, const REFLECTABLE_PTR& reflectable) |
|
181 |
{ |
||
182 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗ |
64 |
const ITypeInfo& typeInfo = reflectable->getTypeInfo(); |
183 |
64 |
bool match = false; |
|
184 |
✓✗✓✗ ✗✓✓✗ ✓✗✗✓ ✓✗✓✗ ✗✓✓✗ ✓✗✗✓ ✓✗✓✗ ✗✓✓✗ ✓✗✗✓ ✓✗✓✗ ✗✓✓✗ ✓✗✗✓ ✓✗✓✗ ✗✓✓✗ ✓✗✗✓ ✓✗✓✗ ✗✓✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗ |
64 |
if (TypeInfoUtil::isFloatingPoint(typeInfo.getCppType())) |
185 |
{ |
||
186 |
✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗ |
3 |
checkArithmeticCppTypeGetter(value, reflectable, |
187 |
CppType::FLOAT, &IReflectable::getFloat, match); |
||
188 |
✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗ |
3 |
checkArithmeticCppTypeGetter(value, reflectable, |
189 |
CppType::DOUBLE, &IReflectable::getDouble, match); |
||
190 |
} |
||
191 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✓✗✓✗ ✗✓✓✗ ✓✗✗✓ ✓✗✓✗ ✗✓✓✗ ✓✗✗✓ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
61 |
else if (TypeInfoUtil::isSigned(typeInfo.getCppType())) |
192 |
{ |
||
193 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
31 |
ASSERT_EQ(static_cast<int64_t>(value), reflectable->toInt()); |
194 |
|||
195 |
✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗ |
31 |
checkArithmeticCppTypeGetter(value, reflectable, |
196 |
CppType::INT8, &IReflectable::getInt8, match); |
||
197 |
✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗ |
31 |
checkArithmeticCppTypeGetter(value, reflectable, |
198 |
CppType::INT16, &IReflectable::getInt16, match); |
||
199 |
✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗ |
31 |
checkArithmeticCppTypeGetter(value, reflectable, |
200 |
CppType::INT32, &IReflectable::getInt32, match); |
||
201 |
✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗ |
31 |
checkArithmeticCppTypeGetter(value, reflectable, |
202 |
CppType::INT64, &IReflectable::getInt64, match); |
||
203 |
} |
||
204 |
else |
||
205 |
{ |
||
206 |
✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
30 |
ASSERT_EQ(static_cast<uint64_t>(value), reflectable->toUInt()); |
207 |
|||
208 |
✗✗✓✗ ✓✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗ |
30 |
checkArithmeticCppTypeGetter(value, reflectable, |
209 |
CppType::BOOL, &IReflectable::getBool, match); |
||
210 |
✗✗✓✗ ✓✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗ |
30 |
checkArithmeticCppTypeGetter(value, reflectable, |
211 |
CppType::UINT8, &IReflectable::getUInt8, match); |
||
212 |
✗✗✓✗ ✓✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗ |
30 |
checkArithmeticCppTypeGetter(value, reflectable, |
213 |
CppType::UINT16, &IReflectable::getUInt16, match); |
||
214 |
✗✗✓✗ ✓✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗ |
30 |
checkArithmeticCppTypeGetter(value, reflectable, |
215 |
CppType::UINT32, &IReflectable::getUInt32, match); |
||
216 |
✗✗✓✗ ✓✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗ |
30 |
checkArithmeticCppTypeGetter(value, reflectable, |
217 |
CppType::UINT64, &IReflectable::getUInt64, match); |
||
218 |
} |
||
219 |
|||
220 |
✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ |
64 |
ASSERT_TRUE(match); |
221 |
} |
||
222 |
|||
223 |
template <typename T, typename REFLECTABLE_PTR, typename GETTER, typename READ_FUNC> |
||
224 |
3 |
void checkFloatingPoint(T value, const REFLECTABLE_PTR& reflectable, |
|
225 |
const GETTER& getter, const READ_FUNC& readFunc, size_t bitSize = sizeof(T) * 8) |
||
226 |
{ |
||
227 |
✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
3 |
ASSERT_EQ(value, ((*reflectable).*getter)()); |
228 |
|||
229 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗ |
3 |
ASSERT_EQ(value, reflectable->toDouble()); |
230 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
6 |
ASSERT_THROW(reflectable->toInt(), CppRuntimeException); |
231 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
6 |
ASSERT_THROW(reflectable->toUInt(), CppRuntimeException); |
232 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
6 |
ASSERT_THROW(reflectable->toString(), CppRuntimeException); // NOT IMPLEMENTED! |
233 |
|||
234 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
6 |
ASSERT_THROW(reflectable->getInt8(), CppRuntimeException); |
235 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
6 |
ASSERT_THROW(reflectable->getInt16(), CppRuntimeException); |
236 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
6 |
ASSERT_THROW(reflectable->getInt32(), CppRuntimeException); |
237 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
6 |
ASSERT_THROW(reflectable->getInt64(), CppRuntimeException); |
238 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
6 |
ASSERT_THROW(reflectable->getUInt8(), CppRuntimeException); |
239 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
6 |
ASSERT_THROW(reflectable->getUInt16(), CppRuntimeException); |
240 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
6 |
ASSERT_THROW(reflectable->getUInt32(), CppRuntimeException); |
241 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
6 |
ASSERT_THROW(reflectable->getUInt64(), CppRuntimeException); |
242 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
6 |
ASSERT_THROW(reflectable->getBytes(), CppRuntimeException); |
243 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
6 |
ASSERT_THROW(reflectable->getStringView(), CppRuntimeException); |
244 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
6 |
ASSERT_THROW(reflectable->getBitBuffer(), CppRuntimeException); |
245 |
|||
246 |
3 |
checkArithmeticCppTypeGetters(value, reflectable); |
|
247 |
|||
248 |
3 |
checkNonCompound(reflectable); |
|
249 |
3 |
checkNonArray(reflectable); |
|
250 |
|||
251 |
3 |
checkWriteRead(value, reflectable, readFunc, bitSize); |
|
252 |
} |
||
253 |
|||
254 |
template <typename T, typename REFLECTABLE_PTR, typename GETTER, typename READ_FUNC> |
||
255 |
61 |
void checkIntegral(T value, const REFLECTABLE_PTR& reflectable, |
|
256 |
const GETTER& getter, const READ_FUNC& readFunc, size_t bitSize) |
||
257 |
{ |
||
258 |
✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✓✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
61 |
ASSERT_EQ(value, ((*reflectable).*getter)()); |
259 |
|||
260 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
61 |
ASSERT_EQ(value, reflectable->getAnyValue().template get<T>()); |
261 |
|||
262 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
61 |
ASSERT_DOUBLE_EQ(static_cast<double>(value), reflectable->toDouble()); |
263 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✓ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗ |
61 |
ASSERT_EQ(zserio::toString(value), reflectable->toString()); |
264 |
|||
265 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗ |
122 |
ASSERT_THROW(reflectable->getFloat(), CppRuntimeException); |
266 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗ |
122 |
ASSERT_THROW(reflectable->getDouble(), CppRuntimeException); |
267 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗ |
122 |
ASSERT_THROW(reflectable->getBytes(), CppRuntimeException); |
268 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗ |
122 |
ASSERT_THROW(reflectable->getStringView(), CppRuntimeException); |
269 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
122 |
ASSERT_THROW(reflectable->getBitBuffer(), CppRuntimeException); |
270 |
|||
271 |
61 |
checkArithmeticCppTypeGetters(value, reflectable); |
|
272 |
|||
273 |
61 |
checkNonCompound(reflectable); |
|
274 |
61 |
checkNonArray(reflectable); |
|
275 |
|||
276 |
61 |
checkWriteRead(value, reflectable, readFunc, bitSize); |
|
277 |
} |
||
278 |
|||
279 |
template <typename T, typename REFLECTABLE_PTR, typename GETTER, typename READ_FUNC> |
||
280 |
31 |
void checkSignedIntegral(T value, const REFLECTABLE_PTR& reflectable, |
|
281 |
const GETTER& getter, const READ_FUNC& readFunc, size_t bitSize = sizeof(T) * 8) |
||
282 |
{ |
||
283 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✓ ✗✓✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✓ ✗✓✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✓ ✗✓✗✗ |
31 |
ASSERT_EQ(value, reflectable->toInt()); |
284 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ |
62 |
ASSERT_THROW(reflectable->toUInt(), CppRuntimeException); |
285 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
62 |
ASSERT_THROW(reflectable->getBool(), CppRuntimeException); // bool is unsigned integral type |
286 |
|||
287 |
31 |
checkIntegral(value, reflectable, getter, readFunc, bitSize); |
|
288 |
} |
||
289 |
|||
290 |
template <typename T, typename REFLECTABLE_PTR, typename GETTER, typename READ_FUNC> |
||
291 |
30 |
void checkUnsignedIntegral(T value, const REFLECTABLE_PTR& reflectable, |
|
292 |
const GETTER& getter, const READ_FUNC& readFunc, size_t bitSize = sizeof(T) * 8) |
||
293 |
{ |
||
294 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✓ ✗✓✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✓ ✗✓✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✓ ✗✓✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✗ |
30 |
ASSERT_EQ(value, reflectable->toUInt()); |
295 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
60 |
ASSERT_THROW(reflectable->toInt(), CppRuntimeException); |
296 |
|||
297 |
30 |
checkIntegral(value, reflectable, getter, readFunc, bitSize); |
|
298 |
} |
||
299 |
|||
300 |
template <typename REFLECTABLE_PTR> |
||
301 |
11 |
void checkString(StringView value, const REFLECTABLE_PTR& reflectable) |
|
302 |
{ |
||
303 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
11 |
ASSERT_EQ(value, reflectable->getStringView()); |
304 |
|||
305 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
11 |
ASSERT_EQ(value, reflectable->getAnyValue().template get<StringView>()); |
306 |
|||
307 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗ |
11 |
ASSERT_EQ(toString(value), reflectable->toString()); |
308 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->toInt(), CppRuntimeException); |
309 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->toUInt(), CppRuntimeException); |
310 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->toDouble(), CppRuntimeException); |
311 |
|||
312 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->getBool(), CppRuntimeException); |
313 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->getInt8(), CppRuntimeException); |
314 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->getInt16(), CppRuntimeException); |
315 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->getInt32(), CppRuntimeException); |
316 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->getInt64(), CppRuntimeException); |
317 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->getUInt8(), CppRuntimeException); |
318 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->getUInt16(), CppRuntimeException); |
319 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->getUInt32(), CppRuntimeException); |
320 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->getUInt64(), CppRuntimeException); |
321 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->getFloat(), CppRuntimeException); |
322 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->getDouble(), CppRuntimeException); |
323 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
22 |
ASSERT_THROW(reflectable->getBitBuffer(), CppRuntimeException); |
324 |
|||
325 |
11 |
checkNonCompound(reflectable); |
|
326 |
11 |
checkNonArray(reflectable); |
|
327 |
|||
328 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ |
11 |
checkWriteRead(toString(value), reflectable, |
329 |
std::bind(&BitStreamReader::readString<>, _1, std::allocator<uint8_t>()), |
||
330 |
11 |
bitSizeOfVarSize(convertSizeToUInt32(value.size())) + value.size() * 8); |
|
331 |
} |
||
332 |
|||
333 |
template <typename REFLECTABLE_PTR> |
||
334 |
5 |
void checkBitBuffer(const BitBuffer& value, const REFLECTABLE_PTR& reflectable) |
|
335 |
{ |
||
336 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
5 |
ASSERT_EQ(value, reflectable->getBitBuffer()); |
337 |
|||
338 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗ |
5 |
ASSERT_EQ(value, reflectable->getAnyValue(). |
339 |
template get<std::reference_wrapper<const BitBuffer>>().get()); |
||
340 |
|||
341 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
10 |
ASSERT_THROW(reflectable->toString(), CppRuntimeException); |
342 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
10 |
ASSERT_THROW(reflectable->toDouble(), CppRuntimeException); |
343 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
10 |
ASSERT_THROW(reflectable->toInt(), CppRuntimeException); |
344 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
10 |
ASSERT_THROW(reflectable->toUInt(), CppRuntimeException); |
345 |
|||
346 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
10 |
ASSERT_THROW(reflectable->getInt8(), CppRuntimeException); |
347 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
10 |
ASSERT_THROW(reflectable->getInt16(), CppRuntimeException); |
348 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
10 |
ASSERT_THROW(reflectable->getInt32(), CppRuntimeException); |
349 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
10 |
ASSERT_THROW(reflectable->getInt64(), CppRuntimeException); |
350 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
10 |
ASSERT_THROW(reflectable->getUInt8(), CppRuntimeException); |
351 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
10 |
ASSERT_THROW(reflectable->getUInt16(), CppRuntimeException); |
352 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
10 |
ASSERT_THROW(reflectable->getUInt32(), CppRuntimeException); |
353 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
10 |
ASSERT_THROW(reflectable->getUInt64(), CppRuntimeException); |
354 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
10 |
ASSERT_THROW(reflectable->getFloat(), CppRuntimeException); |
355 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
10 |
ASSERT_THROW(reflectable->getDouble(), CppRuntimeException); |
356 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
10 |
ASSERT_THROW(reflectable->getBytes(), CppRuntimeException); |
357 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
10 |
ASSERT_THROW(reflectable->getStringView(), CppRuntimeException); |
358 |
|||
359 |
5 |
checkNonCompound(reflectable); |
|
360 |
5 |
checkNonArray(reflectable); |
|
361 |
|||
362 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ |
5 |
checkWriteRead(value, reflectable, |
363 |
std::bind(&BitStreamReader::readBitBuffer<>, _1, std::allocator<uint8_t>()), |
||
364 |
5 |
bitSizeOfVarSize(convertSizeToUInt32(value.getBitSize())) + value.getBitSize()); |
|
365 |
} |
||
366 |
|||
367 |
template <typename REFLECTABLE_PTR> |
||
368 |
5 |
void checkBytes(const std::vector<uint8_t>& value, const REFLECTABLE_PTR& reflectable) |
|
369 |
{ |
||
370 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
5 |
ASSERT_EQ(value.data(), reflectable->getBytes().data()); |
371 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
5 |
ASSERT_EQ(value.size(), reflectable->getBytes().size()); |
372 |
✓✗✓✗ ✓✗✓✗ |
5 |
auto anyValue = reflectable->getAnyValue().template get<Span<const uint8_t>>(); |
373 |
✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
5 |
ASSERT_EQ(value.data(), anyValue.data()); |
374 |
✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗ |
5 |
ASSERT_EQ(value.size(), anyValue.size()); |
375 |
|||
376 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
10 |
ASSERT_THROW(reflectable->toString(), CppRuntimeException); |
377 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
10 |
ASSERT_THROW(reflectable->toDouble(), CppRuntimeException); |
378 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
10 |
ASSERT_THROW(reflectable->toInt(), CppRuntimeException); |
379 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
10 |
ASSERT_THROW(reflectable->toUInt(), CppRuntimeException); |
380 |
|||
381 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
10 |
ASSERT_THROW(reflectable->getInt8(), CppRuntimeException); |
382 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
10 |
ASSERT_THROW(reflectable->getInt16(), CppRuntimeException); |
383 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
10 |
ASSERT_THROW(reflectable->getInt32(), CppRuntimeException); |
384 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
10 |
ASSERT_THROW(reflectable->getInt64(), CppRuntimeException); |
385 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
10 |
ASSERT_THROW(reflectable->getUInt8(), CppRuntimeException); |
386 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
10 |
ASSERT_THROW(reflectable->getUInt16(), CppRuntimeException); |
387 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
10 |
ASSERT_THROW(reflectable->getUInt32(), CppRuntimeException); |
388 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
10 |
ASSERT_THROW(reflectable->getUInt64(), CppRuntimeException); |
389 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
10 |
ASSERT_THROW(reflectable->getFloat(), CppRuntimeException); |
390 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
10 |
ASSERT_THROW(reflectable->getDouble(), CppRuntimeException); |
391 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
10 |
ASSERT_THROW(reflectable->getStringView(), CppRuntimeException); |
392 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
10 |
ASSERT_THROW(reflectable->getBitBuffer(), CppRuntimeException); |
393 |
|||
394 |
✓✗✓✗ |
5 |
checkNonCompound(reflectable); |
395 |
✓✗✓✗ |
5 |
checkNonArray(reflectable); |
396 |
|||
397 |
5 |
const size_t bitSize = value.size() * 8; |
|
398 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ |
5 |
checkWriteRead(value, reflectable, |
399 |
std::bind(&BitStreamReader::readBytes<>, _1, std::allocator<uint8_t>()), |
||
400 |
✓✗✓✗ ✓✗✓✗ |
5 |
bitSizeOfVarSize(convertSizeToUInt32(bitSize)) + bitSize); |
401 |
} |
||
402 |
|||
403 |
template <typename REFLECTABLE_PTR> |
||
404 |
11 |
void checkBitmask(ReflectableBitmask bitmask, const REFLECTABLE_PTR& reflectable) |
|
405 |
{ |
||
406 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
11 |
ASSERT_EQ(bitmask.getValue(), reflectable->getUInt8()); |
407 |
|||
408 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
11 |
ASSERT_EQ(bitmask, reflectable->getAnyValue().template get<ReflectableBitmask>()); |
409 |
|||
410 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
11 |
ASSERT_EQ(bitmask.getValue(), reflectable->toUInt()); |
411 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
11 |
ASSERT_EQ(bitmask.getValue(), reflectable->toDouble()); |
412 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗ |
11 |
ASSERT_EQ(bitmask.toString(), reflectable->toString()); |
413 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
22 |
ASSERT_THROW(reflectable->toInt(), CppRuntimeException); |
414 |
|||
415 |
11 |
checkNonCompound(reflectable); |
|
416 |
11 |
checkNonArray(reflectable); |
|
417 |
|||
418 |
✓✗✓✗ |
11 |
checkWriteRead(bitmask, reflectable, |
419 |
11 |
[](BitStreamReader& reader) { |
|
420 |
return ReflectableBitmask(reader); |
||
421 |
11 |
}, 8 |
|
422 |
); |
||
423 |
} |
||
424 |
|||
425 |
template <typename REFLECTABLE_PTR> |
||
426 |
10 |
void checkEnum(ReflectableEnum enumeration, const REFLECTABLE_PTR& reflectable) |
|
427 |
{ |
||
428 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
10 |
ASSERT_EQ(enumToValue(enumeration), reflectable->getInt8()); |
429 |
|||
430 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
10 |
ASSERT_EQ(enumeration, reflectable->getAnyValue().template get<ReflectableEnum>()); |
431 |
|||
432 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
10 |
ASSERT_EQ(enumToValue(enumeration), reflectable->toInt()); |
433 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
10 |
ASSERT_EQ(enumToValue(enumeration), reflectable->toDouble()); |
434 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✓✗✓ ✗✗✓✗ ✗✗✗✗ ✗✓✗✓ ✗✗ |
10 |
ASSERT_EQ(enumToString(enumeration), reflectable->toString()); |
435 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
20 |
ASSERT_THROW(reflectable->toUInt(), CppRuntimeException); |
436 |
|||
437 |
10 |
checkNonCompound(reflectable); |
|
438 |
10 |
checkNonArray(reflectable); |
|
439 |
|||
440 |
✓✗✓✗ |
10 |
checkWriteRead(enumeration, reflectable, |
441 |
10 |
[](BitStreamReader& reader) { |
|
442 |
return zserio::read<ReflectableEnum>(reader); |
||
443 |
10 |
}, 8 |
|
444 |
); |
||
445 |
} |
||
446 |
|||
447 |
template <typename REFLECTABLE_PTR> |
||
448 |
11 |
void checkCompoundConstMethods(const ReflectableObject& reflectableObject, |
|
449 |
const REFLECTABLE_PTR& reflectable) |
||
450 |
{ |
||
451 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ |
11 |
ASSERT_TRUE(TypeInfoUtil::isCompound(reflectable->getTypeInfo().getSchemaType())); |
452 |
|||
453 |
// field getter |
||
454 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
11 |
ASSERT_EQ(reflectableObject.getReflectableNested().getValue(), |
455 |
reflectable->getField("reflectableNested")->getField("value")->getUInt32()); |
||
456 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
22 |
ASSERT_THROW(reflectable->getField("nonexistent"), CppRuntimeException); |
457 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
22 |
ASSERT_THROW(reflectable->getField("reflectableNested")->getField("nonexistent"), CppRuntimeException); |
458 |
|||
459 |
// find field |
||
460 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
11 |
ASSERT_EQ(reflectableObject.getReflectableNested().getValue(), |
461 |
reflectable->find("reflectableNested.value")->toUInt()); |
||
462 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
11 |
ASSERT_EQ(reflectableObject.getReflectableNested().getValue(), |
463 |
(*reflectable)["reflectableNested.value"]->toDouble()); |
||
464 |
|||
465 |
// find parameter |
||
466 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
11 |
ASSERT_NO_THROW(reflectable->getField("reflectableNested")->getParameter("dummyParam")); |
467 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
11 |
ASSERT_EQ(13, (*reflectable)["reflectableNested.dummyParam"]->getInt32()); |
468 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
11 |
ASSERT_NO_THROW(reflectable->getField("reflectableNested")->getParameter("stringParam")); |
469 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
11 |
ASSERT_EQ(reflectableObject.getStringField(), |
470 |
(*reflectable)["reflectableNested.stringParam"]->toString()); |
||
471 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
22 |
ASSERT_THROW(reflectable->getField("reflectableNested")->getParameter("nonexistent"), |
472 |
CppRuntimeException); |
||
473 |
|||
474 |
// find function |
||
475 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
11 |
ASSERT_EQ(reflectableObject.getReflectableNested().getValue(), |
476 |
(*reflectable)["reflectableNested.getValue"]->getUInt32()); |
||
477 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
22 |
ASSERT_THROW(reflectable->getField("reflectableNested")->callFunction("nonexistent"), |
478 |
CppRuntimeException); |
||
479 |
|||
480 |
// find failed |
||
481 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
11 |
ASSERT_EQ(nullptr, reflectable->find("reflectableNested.nonexistent")); |
482 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
11 |
ASSERT_EQ(nullptr, reflectable->find("nonexistent")); |
483 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
11 |
ASSERT_EQ(nullptr, reflectable->find("reflectableNested.value.nonexistent")); |
484 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
11 |
ASSERT_EQ(nullptr, reflectable->find("reflectableNested.dummyParam.nonexistent")); |
485 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
11 |
ASSERT_EQ(nullptr, reflectable->find("reflectableNested.getValue.nonexistent")); |
486 |
// find failed because the underlying code throws |
||
487 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
11 |
ASSERT_EQ(nullptr, reflectable->find("reflectableNested.throwingFunction.nonexistent")); |
488 |
|||
489 |
if (std::is_const<typename REFLECTABLE_PTR::element_type>::value) |
||
490 |
{ |
||
491 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
8 |
ASSERT_EQ(reflectableObject, |
492 |
reflectable->getAnyValue(). |
||
493 |
template get<std::reference_wrapper<const ReflectableObject>>().get()); |
||
494 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗ |
8 |
ASSERT_EQ(reflectableObject.getReflectableNested(), reflectable->getField("reflectableNested")-> |
495 |
getAnyValue().template get<std::reference_wrapper<const ReflectableNested>>().get()); |
||
496 |
} |
||
497 |
else |
||
498 |
{ |
||
499 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
3 |
ASSERT_EQ(reflectableObject, |
500 |
reflectable->getAnyValue().template get<std::reference_wrapper<ReflectableObject>>().get()); |
||
501 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗✗ |
3 |
ASSERT_EQ(reflectableObject.getReflectableNested(), reflectable->getField("reflectableNested")-> |
502 |
getAnyValue().template get<std::reference_wrapper<ReflectableNested>>().get()); |
||
503 |
} |
||
504 |
|||
505 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->getBool(), CppRuntimeException); |
506 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->getInt8(), CppRuntimeException); |
507 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->getInt16(), CppRuntimeException); |
508 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->getInt32(), CppRuntimeException); |
509 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->getInt64(), CppRuntimeException); |
510 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->getUInt8(), CppRuntimeException); |
511 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->getUInt16(), CppRuntimeException); |
512 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->getUInt32(), CppRuntimeException); |
513 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->getUInt64(), CppRuntimeException); |
514 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->getFloat(), CppRuntimeException); |
515 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->getDouble(), CppRuntimeException); |
516 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->getBytes(), CppRuntimeException); |
517 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->getStringView(), CppRuntimeException); |
518 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->getBitBuffer(), CppRuntimeException); |
519 |
|||
520 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->toInt(), CppRuntimeException); |
521 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->toUInt(), CppRuntimeException); |
522 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗✓✗✓ ✗✓✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
22 |
ASSERT_THROW(reflectable->toDouble(), CppRuntimeException); |
523 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
22 |
ASSERT_THROW(reflectable->toString(), CppRuntimeException); |
524 |
|||
525 |
11 |
checkNonArray(reflectable); |
|
526 |
|||
527 |
✓✗✓✗ ✓✗✓✗ |
11 |
checkWriteRead(reflectableObject, reflectable, |
528 |
11 |
[](BitStreamReader& reader) { |
|
529 |
return ReflectableObject(reader); |
||
530 |
✓✗✓✗ |
11 |
}, reflectableObject.bitSizeOf() |
531 |
); |
||
532 |
} |
||
533 |
|||
534 |
5 |
void checkCompound(const ReflectableObject& reflectableObject, const IReflectableConstPtr& reflectable) |
|
535 |
{ |
||
536 |
5 |
checkCompoundConstMethods(reflectableObject, reflectable); |
|
537 |
5 |
} |
|
538 |
|||
539 |
3 |
void checkCompound(const ReflectableObject& reflectableObject, const IReflectablePtr& reflectable) |
|
540 |
{ |
||
541 |
3 |
checkCompoundConstMethods(reflectableObject, reflectable); |
|
542 |
✓✗ | 3 |
checkCompoundConstMethods(reflectableObject, static_cast<IReflectableConstPtr>(reflectable)); |
543 |
|||
544 |
// setter |
||
545 |
✓✗✓✗ ✓✗ |
3 |
reflectable->getField("reflectableNested")->setField("value", AnyHolder<>(static_cast<uint32_t>(11))); |
546 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
3 |
ASSERT_EQ(11, reflectableObject.getReflectableNested().getValue()); |
547 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
6 |
ASSERT_THROW(reflectable->setField("nonexistent", AnyHolder<>()), CppRuntimeException); |
548 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
6 |
ASSERT_THROW(reflectable->find("reflectableNested")->setField("nonexistent", AnyHolder<>()), |
549 |
CppRuntimeException); |
||
550 |
|||
551 |
// any value |
||
552 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
3 |
ASSERT_EQ(reflectableObject.getReflectableNested(), reflectable->find("reflectableNested")-> |
553 |
getAnyValue().template get<std::reference_wrapper<ReflectableNested>>().get()); |
||
554 |
|||
555 |
✓✗ | 3 |
reflectable->createField("reflectableNested"); |
556 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
3 |
ASSERT_EQ(uint32_t(), reflectableObject.getReflectableNested().getValue()); |
557 |
|||
558 |
✓✗✓✗ |
3 |
reflectable->setField("reflectableNested", AnyHolder<>(ReflectableNested{42})); |
559 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
3 |
ASSERT_EQ(42, reflectableObject.getReflectableNested().getValue()); |
560 |
3 |
reflectable->initializeChildren(); // keep the reflectable initialized for following tests |
|
561 |
} |
||
562 |
}; |
||
563 |
|||
564 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, boolReflectable) |
565 |
{ |
||
566 |
1 |
const bool value = true; |
|
567 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getBool(value); |
568 |
3 |
checkUnsignedIntegral(value, reflectable, &IReflectable::getBool, |
|
569 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readBool, _1)); |
570 |
1 |
} |
|
571 |
|||
572 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, int8Reflectable) |
573 |
{ |
||
574 |
1 |
const int8_t value = -12; |
|
575 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getInt8(value); |
576 |
3 |
checkSignedIntegral(value, reflectable, &IReflectable::getInt8, |
|
577 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readSignedBits, _1, 8)); |
578 |
1 |
} |
|
579 |
|||
580 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, int16Reflectable) |
581 |
{ |
||
582 |
1 |
const int16_t value = -1234; |
|
583 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getInt16(value); |
584 |
3 |
checkSignedIntegral(value, reflectable, &IReflectable::getInt16, |
|
585 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readSignedBits, _1, 16)); |
586 |
1 |
} |
|
587 |
|||
588 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, int32Reflectable) |
589 |
{ |
||
590 |
1 |
const int32_t value = -123456; |
|
591 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getInt32(value); |
592 |
3 |
checkSignedIntegral(value, reflectable, &IReflectable::getInt32, |
|
593 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readSignedBits, _1, 32)); |
594 |
1 |
} |
|
595 |
|||
596 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, int64Reflectable) |
597 |
{ |
||
598 |
1 |
const int64_t value = -1234567890; |
|
599 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getInt64(value); |
600 |
3 |
checkSignedIntegral(value, reflectable, &IReflectable::getInt64, |
|
601 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readSignedBits64, _1, 64)); |
602 |
1 |
} |
|
603 |
|||
604 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, uint8Reflectable) |
605 |
{ |
||
606 |
1 |
const uint8_t value = 0xFF; |
|
607 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getUInt8(value); |
608 |
3 |
checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt8, |
|
609 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readBits, _1, 8)); |
610 |
1 |
} |
|
611 |
|||
612 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, uint16Reflectable) |
613 |
{ |
||
614 |
1 |
const uint16_t value = 0xFFFF; |
|
615 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getUInt16(value); |
616 |
3 |
checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt16, |
|
617 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readBits, _1, 16)); |
618 |
1 |
} |
|
619 |
|||
620 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, uint32Reflectable) |
621 |
{ |
||
622 |
1 |
const uint32_t value = 0xFFFFFFFF; |
|
623 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getUInt32(value); |
624 |
3 |
checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt32, |
|
625 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readBits, _1, 32)); |
626 |
1 |
} |
|
627 |
|||
628 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, uint64Reflectable) |
629 |
{ |
||
630 |
1 |
const uint64_t value = 0xFFFFFFFFFFFF; |
|
631 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getUInt64(value); |
632 |
3 |
checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt64, |
|
633 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readBits64, _1, 64)); |
634 |
1 |
} |
|
635 |
|||
636 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, fixedSignedBitField5) // mapped to int8_t |
637 |
{ |
||
638 |
1 |
const uint8_t numBits = 5; |
|
639 |
1 |
const int8_t value = 15; |
|
640 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getFixedSignedBitField(numBits, value); |
641 |
2 |
checkSignedIntegral(value, reflectable, &IReflectable::getInt8, |
|
642 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits); |
643 |
|||
644 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(10, value), CppRuntimeException); |
645 |
} |
||
646 |
|||
647 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, fixedSignedBitField15) // mapped to int16_t |
648 |
{ |
||
649 |
1 |
const uint8_t numBits = 15; |
|
650 |
1 |
const int16_t value = -15; |
|
651 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getFixedSignedBitField(numBits, value); |
652 |
2 |
checkSignedIntegral(value, reflectable, &IReflectable::getInt16, |
|
653 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits); |
654 |
|||
655 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(5, value), CppRuntimeException); |
656 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(17, value), CppRuntimeException); |
657 |
} |
||
658 |
|||
659 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, fixedSignedBitField31) // mapped to int32_t |
660 |
{ |
||
661 |
1 |
const uint8_t numBits = 31; |
|
662 |
1 |
const int32_t value = -12345678; |
|
663 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getFixedSignedBitField(numBits, value); |
664 |
2 |
checkSignedIntegral(value, reflectable, &IReflectable::getInt32, |
|
665 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits); |
666 |
|||
667 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(16, value), CppRuntimeException); |
668 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(33, value), CppRuntimeException); |
669 |
} |
||
670 |
|||
671 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, fixedSignedBitField60) // mapped to int64_t |
672 |
{ |
||
673 |
1 |
const uint8_t numBits = 60; |
|
674 |
1 |
const int64_t value = 1234567890; |
|
675 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getFixedSignedBitField(numBits, value); |
676 |
2 |
checkSignedIntegral(value, reflectable, &IReflectable::getInt64, |
|
677 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readSignedBits64, _1, numBits), numBits); |
678 |
|||
679 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(31, value), CppRuntimeException); |
680 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(ReflectableFactory::getFixedSignedBitField(65, value), CppRuntimeException); |
681 |
} |
||
682 |
|||
683 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, fixedUnsignedBitField7) // mapped to uint8_t |
684 |
{ |
||
685 |
1 |
const uint8_t numBits = 7; |
|
686 |
1 |
const uint8_t value = 0x2F; |
|
687 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getFixedUnsignedBitField(numBits, value); |
688 |
2 |
checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt8, |
|
689 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readBits, _1, numBits), numBits); |
690 |
|||
691 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(9, value), CppRuntimeException); |
692 |
} |
||
693 |
|||
694 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, fixedUnsignedBitField9) // mapped to uint16_t |
695 |
{ |
||
696 |
1 |
const uint8_t numBits = 9; |
|
697 |
1 |
const uint16_t value = 0x1FF; |
|
698 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getFixedUnsignedBitField(numBits, value); |
699 |
2 |
checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt16, |
|
700 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readBits, _1, numBits), numBits); |
701 |
|||
702 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(8, value), CppRuntimeException); |
703 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(17, value), CppRuntimeException); |
704 |
} |
||
705 |
|||
706 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, fixedUnsignedBitField31) // mapped to uint32_t |
707 |
{ |
||
708 |
1 |
const uint8_t numBits = 31; |
|
709 |
1 |
const uint32_t value = UINT32_MAX >> 1; |
|
710 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getFixedUnsignedBitField(numBits, value); |
711 |
2 |
checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt32, |
|
712 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readBits, _1, numBits), numBits); |
713 |
|||
714 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(16, value), CppRuntimeException); |
715 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(33, value), CppRuntimeException); |
716 |
} |
||
717 |
|||
718 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, fixedUnsignedBitField33) // mapped to uint64_t |
719 |
{ |
||
720 |
1 |
const uint8_t numBits = 33; |
|
721 |
1 |
const uint64_t value = static_cast<uint64_t>(UINT32_MAX) << 1U; |
|
722 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getFixedUnsignedBitField(numBits, value); |
723 |
2 |
checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt64, |
|
724 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readBits64, _1, numBits), numBits); |
725 |
|||
726 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(32, value), CppRuntimeException); |
727 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(ReflectableFactory::getFixedUnsignedBitField(65, value), CppRuntimeException); |
728 |
} |
||
729 |
|||
730 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, dynamicSignedBitField5) // mapped to int8_t |
731 |
{ |
||
732 |
1 |
const uint8_t maxBitSize = 8; |
|
733 |
1 |
const uint8_t numBits = 5; |
|
734 |
1 |
const int8_t value = 15; |
|
735 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getDynamicSignedBitField(maxBitSize, value, numBits); |
736 |
2 |
checkSignedIntegral(value, reflectable, &IReflectable::getInt8, |
|
737 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits); |
738 |
|||
739 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(9, value, numBits), CppRuntimeException); |
740 |
} |
||
741 |
|||
742 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, dynamicSignedBitField15) // mapped to int16_t |
743 |
{ |
||
744 |
1 |
const uint8_t maxBitSize = 16; |
|
745 |
1 |
const uint8_t numBits = 15; |
|
746 |
1 |
const int16_t value = -15; |
|
747 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getDynamicSignedBitField(maxBitSize, value, numBits); |
748 |
2 |
checkSignedIntegral(value, reflectable, &IReflectable::getInt16, |
|
749 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits); |
750 |
|||
751 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(8, value, numBits), CppRuntimeException); |
752 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(17, value, numBits), CppRuntimeException); |
753 |
} |
||
754 |
|||
755 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, dynamicSignedBitField31) // mapped to int32_t |
756 |
{ |
||
757 |
1 |
const uint8_t maxBitSize = 32; |
|
758 |
1 |
const uint8_t numBits = 31; |
|
759 |
1 |
const int32_t value = -12345678; |
|
760 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getDynamicSignedBitField(maxBitSize, value, numBits); |
761 |
2 |
checkSignedIntegral(value, reflectable, &IReflectable::getInt32, |
|
762 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits); |
763 |
|||
764 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(16, value, numBits), CppRuntimeException); |
765 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(33, value, numBits), CppRuntimeException); |
766 |
} |
||
767 |
|||
768 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, dynamicSignedBitField60) // mapped to int64_t |
769 |
{ |
||
770 |
1 |
const uint8_t maxBitSize = 64; |
|
771 |
1 |
const uint8_t numBits = 60; |
|
772 |
1 |
const int64_t value = 1234567890; |
|
773 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getDynamicSignedBitField(maxBitSize, value, numBits); |
774 |
2 |
checkSignedIntegral(value, reflectable, &IReflectable::getInt64, |
|
775 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readSignedBits64, _1, numBits), numBits); |
776 |
|||
777 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(32, value, numBits), CppRuntimeException); |
778 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(ReflectableFactory::getDynamicSignedBitField(65, value, numBits), CppRuntimeException); |
779 |
} |
||
780 |
|||
781 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, dynamicUnsignedBitField7) // mapped to uint8_t |
782 |
{ |
||
783 |
1 |
const uint8_t maxBitSize = 8; |
|
784 |
1 |
const uint8_t numBits = 7; |
|
785 |
1 |
const uint8_t value = 0x2F; |
|
786 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getDynamicUnsignedBitField(maxBitSize, value, numBits); |
787 |
2 |
checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt8, |
|
788 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readBits, _1, numBits), numBits); |
789 |
|||
790 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(9, value, numBits), CppRuntimeException); |
791 |
} |
||
792 |
|||
793 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, dynamicUnsignedBitField9) // mapped to uint16_t |
794 |
{ |
||
795 |
1 |
const uint8_t maxBitSize = 16; |
|
796 |
1 |
const uint8_t numBits = 9; |
|
797 |
1 |
const uint16_t value = 0x1FF; |
|
798 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getDynamicUnsignedBitField(maxBitSize, value, numBits); |
799 |
2 |
checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt16, |
|
800 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readBits, _1, numBits), numBits); |
801 |
|||
802 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(8, value, numBits), CppRuntimeException); |
803 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(17, value, numBits), CppRuntimeException); |
804 |
} |
||
805 |
|||
806 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, dynamicUnsignedBitField31) // mapped to uint32_t |
807 |
{ |
||
808 |
1 |
const uint8_t maxBitSize = 32; |
|
809 |
1 |
const uint8_t numBits = 31; |
|
810 |
1 |
const uint32_t value = UINT32_MAX >> 1; |
|
811 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getDynamicUnsignedBitField(maxBitSize, value, numBits); |
812 |
2 |
checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt32, |
|
813 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readBits, _1, numBits), numBits); |
814 |
|||
815 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(16, value, numBits), CppRuntimeException); |
816 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(33, value, numBits), CppRuntimeException); |
817 |
} |
||
818 |
|||
819 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, dynamicUnsignedBitField33) // mapped to uint64_t |
820 |
{ |
||
821 |
1 |
const uint8_t maxBitSize = 64; |
|
822 |
1 |
const uint8_t numBits = 33; |
|
823 |
1 |
const uint64_t value = static_cast<uint64_t>(UINT32_MAX) << 1U; |
|
824 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getDynamicUnsignedBitField(maxBitSize, value, numBits); |
825 |
2 |
checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt64, |
|
826 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readBits64, _1, numBits), numBits); |
827 |
|||
828 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(32, value, numBits), CppRuntimeException); |
829 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(ReflectableFactory::getDynamicUnsignedBitField(65, value, numBits), CppRuntimeException); |
830 |
} |
||
831 |
|||
832 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, varint16Reflectable) |
833 |
{ |
||
834 |
1 |
const int16_t value = -1234; |
|
835 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getVarInt16(value); |
836 |
✓✗ | 3 |
checkSignedIntegral(value, reflectable, &IReflectable::getInt16, |
837 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readVarInt16, _1), bitSizeOfVarInt16(value)); |
838 |
1 |
} |
|
839 |
|||
840 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, varint32Reflectable) |
841 |
{ |
||
842 |
1 |
const int32_t value = 54321; |
|
843 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getVarInt32(value); |
844 |
✓✗ | 3 |
checkSignedIntegral(value, reflectable, &IReflectable::getInt32, |
845 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readVarInt32, _1), bitSizeOfVarInt32(value)); |
846 |
1 |
} |
|
847 |
|||
848 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, varint64Reflectable) |
849 |
{ |
||
850 |
1 |
const int64_t value = -87654321; |
|
851 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getVarInt64(value); |
852 |
✓✗ | 3 |
checkSignedIntegral(value, reflectable, &IReflectable::getInt64, |
853 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readVarInt64, _1), bitSizeOfVarInt64(value)); |
854 |
1 |
} |
|
855 |
|||
856 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, varintReflectable) |
857 |
{ |
||
858 |
1 |
const int64_t value = INT64_MAX; |
|
859 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getVarInt(value); |
860 |
✓✗ | 3 |
checkSignedIntegral(value, reflectable, &IReflectable::getInt64, |
861 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readVarInt, _1), bitSizeOfVarInt(value)); |
862 |
1 |
} |
|
863 |
|||
864 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, varuint16Reflectable) |
865 |
{ |
||
866 |
1 |
const uint16_t value = 1234; |
|
867 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getVarUInt16(value); |
868 |
✓✗ | 3 |
checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt16, |
869 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readVarUInt16, _1), bitSizeOfVarUInt16(value)); |
870 |
1 |
} |
|
871 |
|||
872 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, varuint32Reflectable) |
873 |
{ |
||
874 |
1 |
const uint32_t value = 0x1FFFFFFF; |
|
875 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getVarUInt32(value); |
876 |
✓✗ | 3 |
checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt32, |
877 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readVarUInt32, _1), bitSizeOfVarUInt32(value)); |
878 |
1 |
} |
|
879 |
|||
880 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, varuint64Reflectable) |
881 |
{ |
||
882 |
1 |
const uint64_t value = 4242424242; |
|
883 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getVarUInt64(value); |
884 |
✓✗ | 3 |
checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt64, |
885 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readVarUInt64, _1), bitSizeOfVarUInt64(value)); |
886 |
1 |
} |
|
887 |
|||
888 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, varuintReflectable) |
889 |
{ |
||
890 |
1 |
const uint64_t value = UINT64_MAX; |
|
891 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getVarUInt(value); |
892 |
✓✗ | 3 |
checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt64, |
893 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readVarUInt, _1), bitSizeOfVarUInt(value)); |
894 |
1 |
} |
|
895 |
|||
896 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, varsizeReflectable) |
897 |
{ |
||
898 |
1 |
const uint32_t value = (UINT32_C(1) << (7+7+7+7+3)) - 1; |
|
899 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getVarSize(value); |
900 |
✓✗ | 3 |
checkUnsignedIntegral(value, reflectable, &IReflectable::getUInt32, |
901 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readVarSize, _1), bitSizeOfVarSize(value)); |
902 |
1 |
} |
|
903 |
|||
904 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, float16Reflectable) |
905 |
{ |
||
906 |
1 |
const float value = 2.0F; |
|
907 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getFloat16(value); |
908 |
3 |
checkFloatingPoint(value, reflectable, &IReflectable::getFloat, |
|
909 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readFloat16, _1)); |
910 |
1 |
} |
|
911 |
|||
912 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, float32Reflectable) |
913 |
{ |
||
914 |
1 |
const float value = 1.2F; |
|
915 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getFloat32(value); |
916 |
3 |
checkFloatingPoint(value, reflectable, &IReflectable::getFloat, |
|
917 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readFloat32, _1)); |
918 |
1 |
} |
|
919 |
|||
920 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, float64Reflectable) |
921 |
{ |
||
922 |
1 |
const double value = 1.2; |
|
923 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getFloat64(value); |
924 |
3 |
checkFloatingPoint(value, reflectable, &IReflectable::getDouble, |
|
925 |
✓✗✓✗ |
3 |
std::bind(&BitStreamReader::readFloat64, _1)); |
926 |
1 |
} |
|
927 |
|||
928 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, stringReflectable) |
929 |
{ |
||
930 |
✓✗ | 2 |
const std::string value = "some longer string value to have a chance that some allocation hopefully occurs"; |
931 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getString(value); |
932 |
✓✗ | 1 |
checkString(value, reflectable); |
933 |
1 |
} |
|
934 |
|||
935 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, stringViewReflectable) |
936 |
{ |
||
937 |
1 |
auto view = makeStringView("some text as a string view"); |
|
938 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getString(view); |
939 |
✓✗ | 1 |
checkString(view, reflectable); |
940 |
1 |
} |
|
941 |
|||
942 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, bitBufferReflectable) |
943 |
{ |
||
944 |
✓✗✓✗ |
2 |
const BitBuffer value = BitBuffer{std::vector<uint8_t>({0xAB, 0xF0}), 12}; |
945 |
✓✗ | 2 |
auto reflectable = ReflectableFactory::getBitBuffer(value); |
946 |
✓✗ | 1 |
checkBitBuffer(value, reflectable); |
947 |
1 |
} |
|
948 |
|||
949 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, bytesReflectable) |
950 |
{ |
||
951 |
✓✗ | 2 |
const vector<uint8_t> value{{0, 127, 128, 255}}; |
952 |
✓✗✓✗ |
2 |
auto reflectable = ReflectableFactory::getBytes(value); |
953 |
✓✗ | 1 |
checkBytes(value, reflectable); |
954 |
1 |
} |
|
955 |
|||
956 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, uint8ConstArray) |
957 |
{ |
||
958 |
✓✗ | 2 |
const auto rawArray = std::vector<uint8_t>({10, 20, 30, 40}); |
959 |
✓✗ | 1 |
const ITypeInfo& typeInfo = BuiltinTypeInfo<>::getUInt8(); |
960 |
✓✗✓✗ |
2 |
auto reflectable = ReflectableFactory::getBuiltinArray(typeInfo, rawArray); |
961 |
✓✗✗ | 2 |
checkArray(rawArray, reflectable, |
962 |
4 |
[&](uint8_t value, const IReflectableConstPtr& elementReflectable) { |
|
963 |
16 |
checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt8, |
|
964 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readBits, _1, 8)); |
965 |
4 |
} |
|
966 |
✓✗ | 1 |
); |
967 |
|||
968 |
✓✗ | 2 |
auto nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable); |
969 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
2 |
ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException); |
970 |
|||
971 |
// call version with dynamic bit size |
||
972 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(ReflectableFactory::getBuiltinArray(typeInfo, rawArray, 8), CppRuntimeException); |
973 |
} |
||
974 |
|||
975 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, uint8Array) |
976 |
{ |
||
977 |
✓✗ | 2 |
auto rawArray = std::vector<uint8_t>{{10, 20, 30, 40}}; |
978 |
✓✗ | 1 |
const ITypeInfo& typeInfo = BuiltinTypeInfo<>::getUInt8(); |
979 |
✓✗✓✗ |
2 |
auto reflectable = ReflectableFactory::getBuiltinArray(typeInfo, rawArray); |
980 |
2 |
checkArray(rawArray, reflectable, |
|
981 |
4 |
[&](uint8_t value, const IReflectablePtr& elementReflectable) { |
|
982 |
16 |
checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt8, |
|
983 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readBits, _1, 8)); |
984 |
4 |
} |
|
985 |
✓✗ | 1 |
); |
986 |
2 |
checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable), |
|
987 |
4 |
[&](uint8_t value, const IReflectableConstPtr& elementReflectable) { |
|
988 |
16 |
checkUnsignedIntegral(value, elementReflectable, &IReflectable::getUInt8, |
|
989 |
✓✗✓✗ |
16 |
std::bind(&BitStreamReader::readBits, _1, 8)); |
990 |
4 |
} |
|
991 |
✓✗ | 1 |
); |
992 |
|||
993 |
// call version with dynamic bit size |
||
994 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(ReflectableFactory::getBuiltinArray(typeInfo, rawArray, 8), CppRuntimeException); |
995 |
|||
996 |
✓✗ | 1 |
reflectable->resize(0); |
997 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(0, reflectable->size()); |
998 |
✓✗✓✗ |
1 |
reflectable->append(AnyHolder<>(static_cast<uint8_t>(13))); |
999 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(1, reflectable->size()); |
1000 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(13, reflectable->at(0)->getUInt8()); |
1001 |
✓✗✓✗ |
1 |
reflectable->setAt(AnyHolder<>(static_cast<uint8_t>(42)), 0); |
1002 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(1, reflectable->size()); |
1003 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(42, reflectable->at(0)->getUInt8()); |
1004 |
✓✗ | 1 |
reflectable->resize(2); |
1005 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(2, reflectable->size()); |
1006 |
|||
1007 |
// out of range |
||
1008 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(reflectable->setAt(AnyHolder<>(static_cast<uint8_t>(42)), 2), CppRuntimeException); |
1009 |
} |
||
1010 |
|||
1011 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, dynamicSignedBitField5ConstArray) |
1012 |
{ |
||
1013 |
1 |
const uint8_t maxBitSize = 8; |
|
1014 |
1 |
const uint8_t numBits = 5; |
|
1015 |
✓✗ | 2 |
const auto rawArray = std::vector<int8_t>{{-3, -1, 2, 4, 6}}; |
1016 |
✓✗ | 1 |
const ITypeInfo& typeInfo = BuiltinTypeInfo<>::getDynamicSignedBitField(maxBitSize); |
1017 |
✓✗✓✗ |
2 |
auto reflectable = ReflectableFactory::getBuiltinArray(typeInfo, rawArray, numBits); |
1018 |
✓✗✗ | 2 |
checkArray(rawArray, reflectable, |
1019 |
5 |
[&](int8_t value, const IReflectableConstPtr& elementReflectable) { |
|
1020 |
15 |
checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8, |
|
1021 |
✓✗✓✗ |
20 |
std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits); |
1022 |
5 |
} |
|
1023 |
✓✗ | 1 |
); |
1024 |
|||
1025 |
✓✗ | 2 |
auto nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable); |
1026 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
2 |
ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException); |
1027 |
|||
1028 |
// call version without dynamic bit size |
||
1029 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(ReflectableFactory::getBuiltinArray(typeInfo, rawArray), CppRuntimeException); |
1030 |
} |
||
1031 |
|||
1032 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, dynamicSignedBitField5Array) |
1033 |
{ |
||
1034 |
1 |
const uint8_t maxBitSize = 8; |
|
1035 |
1 |
const uint8_t numBits = 5; |
|
1036 |
✓✗ | 2 |
auto rawArray = std::vector<int8_t>{{-3, -1, 2, 4, 6}}; |
1037 |
✓✗ | 1 |
const ITypeInfo& typeInfo = BuiltinTypeInfo<>::getDynamicSignedBitField(maxBitSize); |
1038 |
✓✗✓✗ |
2 |
auto reflectable = ReflectableFactory::getBuiltinArray(typeInfo, rawArray, numBits); |
1039 |
2 |
checkArray(rawArray, reflectable, |
|
1040 |
5 |
[&](int8_t value, const IReflectablePtr& elementReflectable) { |
|
1041 |
15 |
checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8, |
|
1042 |
✓✗✓✗ |
20 |
std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits); |
1043 |
5 |
} |
|
1044 |
✓✗ | 1 |
); |
1045 |
2 |
checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable), |
|
1046 |
5 |
[&](int8_t value, const IReflectableConstPtr& elementReflectable) { |
|
1047 |
15 |
checkSignedIntegral(value, elementReflectable, &IReflectable::getInt8, |
|
1048 |
✓✗✓✗ |
20 |
std::bind(&BitStreamReader::readSignedBits, _1, numBits), numBits); |
1049 |
5 |
} |
|
1050 |
✓✗ | 1 |
); |
1051 |
|||
1052 |
// call version without dynamic bit size |
||
1053 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(ReflectableFactory::getBuiltinArray(typeInfo, rawArray), CppRuntimeException); |
1054 |
|||
1055 |
✓✗ | 1 |
reflectable->resize(0); |
1056 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(0, reflectable->size()); |
1057 |
✓✗✓✗ |
1 |
reflectable->append(AnyHolder<>(static_cast<int8_t>(13))); |
1058 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(1, reflectable->size()); |
1059 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(13, reflectable->at(0)->getInt8()); |
1060 |
✓✗✓✗ |
1 |
reflectable->setAt(AnyHolder<>(static_cast<int8_t>(42)), 0); |
1061 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(1, reflectable->size()); |
1062 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(42, reflectable->at(0)->getInt8()); |
1063 |
✓✗ | 1 |
reflectable->resize(2); |
1064 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(2, reflectable->size()); |
1065 |
|||
1066 |
// out of range |
||
1067 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(reflectable->setAt(AnyHolder<>(static_cast<int8_t>(42)), 2), CppRuntimeException); |
1068 |
} |
||
1069 |
|||
1070 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, stringConstArray) |
1071 |
{ |
||
1072 |
✓✗✓✗ ✓✗✓✗ ✓✓✗✗ |
2 |
const auto rawArray = std::vector<std::string>{{"one", "two", "three"}}; |
1073 |
✓✗✓✗ ✓✗ |
2 |
auto reflectable = ReflectableFactory::getBuiltinArray(BuiltinTypeInfo<>::getString(), rawArray); |
1074 |
✓✗✗ | 2 |
checkArray(rawArray, reflectable, |
1075 |
3 |
[&](StringView value, const IReflectableConstPtr& elementReflectable) { |
|
1076 |
3 |
checkString(value, elementReflectable); |
|
1077 |
3 |
} |
|
1078 |
✓✗ | 1 |
); |
1079 |
|||
1080 |
✓✗ | 2 |
auto nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable); |
1081 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
2 |
ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException); |
1082 |
} |
||
1083 |
|||
1084 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, stringArray) |
1085 |
{ |
||
1086 |
✓✗✓✗ ✓✗✓✗ ✓✓✗✗ |
2 |
auto rawArray = std::vector<std::string>{{"one", "two", "three"}}; |
1087 |
✓✗✓✗ ✓✗ |
2 |
auto reflectable = ReflectableFactory::getBuiltinArray(BuiltinTypeInfo<>::getString(), rawArray); |
1088 |
2 |
checkArray(rawArray, reflectable, |
|
1089 |
3 |
[&](StringView value, const IReflectablePtr& elementReflectable) { |
|
1090 |
3 |
checkString(value, elementReflectable); |
|
1091 |
3 |
} |
|
1092 |
✓✗ | 1 |
); |
1093 |
2 |
checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable), |
|
1094 |
3 |
[&](StringView value, const IReflectableConstPtr& elementReflectable) { |
|
1095 |
3 |
checkString(value, elementReflectable); |
|
1096 |
3 |
} |
|
1097 |
✓✗ | 1 |
); |
1098 |
|||
1099 |
✓✗ | 1 |
reflectable->resize(0); |
1100 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(0, reflectable->size()); |
1101 |
✓✗✓✗ ✓✗ |
1 |
reflectable->append(AnyHolder<>(std::string("appended"))); |
1102 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(1, reflectable->size()); |
1103 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("appended"_sv, reflectable->at(0)->getStringView()); |
1104 |
✓✗✓✗ ✓✗ |
1 |
reflectable->setAt(AnyHolder<>(std::string("set")), 0); |
1105 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(1, reflectable->size()); |
1106 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ("set"_sv, reflectable->at(0)->getStringView()); |
1107 |
✓✗ | 1 |
reflectable->resize(2); |
1108 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(2, reflectable->size()); |
1109 |
|||
1110 |
// out of range |
||
1111 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(reflectable->setAt(AnyHolder<>(std::string("set")), 2), CppRuntimeException); |
1112 |
} |
||
1113 |
|||
1114 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, bitBufferArray) |
1115 |
{ |
||
1116 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✓ ✗✗ |
2 |
auto rawArray = std::vector<BitBuffer>{{BitBuffer({0xF8}, 5), BitBuffer({0xAB, 0xCD}, 16)}}; |
1117 |
✓✗✓✗ ✓✗ |
2 |
auto reflectable = ReflectableFactory::getBuiltinArray(BuiltinTypeInfo<>::getBitBuffer(), rawArray); |
1118 |
2 |
checkArray(rawArray, reflectable, |
|
1119 |
2 |
[&](const BitBuffer& value, const IReflectablePtr& elementReflectable) { |
|
1120 |
2 |
checkBitBuffer(value, elementReflectable); |
|
1121 |
2 |
} |
|
1122 |
✓✗ | 1 |
); |
1123 |
2 |
checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable), |
|
1124 |
2 |
[&](const BitBuffer& value, const IReflectableConstPtr& elementReflectable) { |
|
1125 |
2 |
checkBitBuffer(value, elementReflectable); |
|
1126 |
2 |
} |
|
1127 |
✓✗ | 1 |
); |
1128 |
|||
1129 |
✓✗ | 1 |
reflectable->resize(0); |
1130 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(0, reflectable->size()); |
1131 |
✓✗✓✗ |
1 |
reflectable->append(AnyHolder<>(BitBuffer())); |
1132 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(1, reflectable->size()); |
1133 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(0, reflectable->at(0)->getBitBuffer().getBitSize()); |
1134 |
✓✗✓✗ ✓✗✓✗ |
1 |
reflectable->setAt(AnyHolder<>(BitBuffer({0xA0}, 4)), 0); |
1135 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(1, reflectable->size()); |
1136 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(4, reflectable->at(0)->getBitBuffer().getBitSize()); |
1137 |
✓✗ | 1 |
reflectable->resize(2); |
1138 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(2, reflectable->size()); |
1139 |
|||
1140 |
// out of range |
||
1141 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(reflectable->setAt(AnyHolder<>(BitBuffer()), 2), CppRuntimeException); |
1142 |
} |
||
1143 |
|||
1144 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, bytesArray) |
1145 |
{ |
||
1146 |
auto rawArray = std::vector<std::vector<uint8_t>>{{ |
||
1147 |
{{0x00, 0x01}}, |
||
1148 |
{{0xFF, 0xFE}} |
||
1149 |
✓✗✓✗ ✓✗✓✓ ✗✗ |
2 |
}}; |
1150 |
✓✗✓✗ ✓✗ |
2 |
auto reflectable = ReflectableFactory::getBuiltinArray(BuiltinTypeInfo<>::getBytes(), rawArray); |
1151 |
2 |
checkArray(rawArray, reflectable, |
|
1152 |
2 |
[&](const vector<uint8_t>& value, const IReflectablePtr& elementReflectable) { |
|
1153 |
|||
1154 |
2 |
checkBytes(value, elementReflectable); |
|
1155 |
2 |
} |
|
1156 |
✓✗ | 1 |
); |
1157 |
2 |
checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable), |
|
1158 |
2 |
[&](const vector<uint8_t>& value, const IReflectableConstPtr& elementReflectable) { |
|
1159 |
|||
1160 |
2 |
checkBytes(value, elementReflectable); |
|
1161 |
2 |
} |
|
1162 |
✓✗ | 1 |
); |
1163 |
|||
1164 |
✓✗ | 1 |
reflectable->resize(0); |
1165 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(0, reflectable->size()); |
1166 |
✓✗✓✗ |
1 |
reflectable->append(AnyHolder<>(std::vector<uint8_t>())); |
1167 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(1, reflectable->size()); |
1168 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(0, reflectable->at(0)->getBytes().size()); |
1169 |
✓✗✓✗ ✓✗ |
1 |
reflectable->setAt(AnyHolder<>(std::vector<uint8_t>{{0xAB, 0xCD}}), 0); |
1170 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(1, reflectable->size()); |
1171 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(2, reflectable->at(0)->getBytes().size()); |
1172 |
✓✗ | 1 |
reflectable->resize(2); |
1173 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(2, reflectable->size()); |
1174 |
|||
1175 |
// out of range |
||
1176 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(reflectable->setAt(AnyHolder<>(std::vector<uint8_t>()), 2), CppRuntimeException); |
1177 |
} |
||
1178 |
|||
1179 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, bitmaskConst) |
1180 |
{ |
||
1181 |
1 |
const ReflectableBitmask bitmask = ReflectableBitmask::Values::WRITE; |
|
1182 |
✓✗ | 2 |
auto reflectable = bitmask.reflectable(); |
1183 |
✓✗ | 1 |
checkBitmask(bitmask, reflectable); |
1184 |
1 |
} |
|
1185 |
|||
1186 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, bitmask) |
1187 |
{ |
||
1188 |
1 |
ReflectableBitmask bitmask = ReflectableBitmask::Values::WRITE; |
|
1189 |
✓✗ | 2 |
auto reflectable = bitmask.reflectable(); |
1190 |
✓✗ | 1 |
checkBitmask(bitmask, reflectable); |
1191 |
1 |
} |
|
1192 |
|||
1193 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, bitmaskConstArray) |
1194 |
{ |
||
1195 |
const auto rawArray = std::vector<ReflectableBitmask>{{ |
||
1196 |
ReflectableBitmask::Values::WRITE, ReflectableBitmask::Values::CREATE, |
||
1197 |
ReflectableBitmask::Values::READ |
||
1198 |
✓✗ | 2 |
}}; |
1199 |
✓✗✓✗ |
2 |
auto reflectable = ReflectableFactory::getBitmaskArray(rawArray); |
1200 |
✓✗✗ | 2 |
checkArray(rawArray, reflectable, |
1201 |
3 |
[&](ReflectableBitmask value, const IReflectableConstPtr& elementReflectable) { |
|
1202 |
3 |
checkBitmask(value, elementReflectable); |
|
1203 |
3 |
} |
|
1204 |
✓✗ | 1 |
); |
1205 |
|||
1206 |
✓✗ | 2 |
auto nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable); |
1207 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
2 |
ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException); |
1208 |
} |
||
1209 |
|||
1210 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, bitmaskArray) |
1211 |
{ |
||
1212 |
auto rawArray = std::vector<ReflectableBitmask>{{ |
||
1213 |
ReflectableBitmask::Values::WRITE, ReflectableBitmask::Values::CREATE, |
||
1214 |
ReflectableBitmask::Values::READ |
||
1215 |
✓✗ | 2 |
}}; |
1216 |
✓✗✓✗ |
2 |
auto reflectable = ReflectableFactory::getBitmaskArray(rawArray); |
1217 |
2 |
checkArray(rawArray, reflectable, |
|
1218 |
3 |
[&](ReflectableBitmask value, const IReflectablePtr& elementReflectable) { |
|
1219 |
3 |
checkBitmask(value, elementReflectable); |
|
1220 |
3 |
} |
|
1221 |
✓✗ | 1 |
); |
1222 |
2 |
checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable), |
|
1223 |
3 |
[&](ReflectableBitmask value, const IReflectableConstPtr& elementReflectable) { |
|
1224 |
3 |
checkBitmask(value, elementReflectable); |
|
1225 |
3 |
} |
|
1226 |
✓✗ | 1 |
); |
1227 |
|||
1228 |
✓✗ | 1 |
reflectable->resize(0); |
1229 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(0, reflectable->size()); |
1230 |
✓✗✓✗ |
1 |
reflectable->append(AnyHolder<>(ReflectableBitmask(ReflectableBitmask::Values::READ))); |
1231 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(1, reflectable->size()); |
1232 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(ReflectableBitmask::Values::READ, ReflectableBitmask(reflectable->at(0)->getUInt8())); |
1233 |
✓✗✓✗ |
1 |
reflectable->setAt(AnyHolder<>(ReflectableBitmask(ReflectableBitmask::Values::CREATE)), 0); |
1234 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(1, reflectable->size()); |
1235 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(ReflectableBitmask::Values::CREATE, ReflectableBitmask(reflectable->at(0)->getUInt8())); |
1236 |
✓✗ | 1 |
reflectable->resize(2); |
1237 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(2, reflectable->size()); |
1238 |
|||
1239 |
✓✗✓✗ |
1 |
reflectable->append(AnyHolder<>(ReflectableBitmask(ReflectableBitmask::Values::WRITE).getValue())); |
1240 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(3, reflectable->size()); |
1241 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(ReflectableBitmask::Values::WRITE, ReflectableBitmask(reflectable->at(2)->getUInt8())); |
1242 |
✓✗✓✗ |
1 |
reflectable->setAt(AnyHolder<>(ReflectableBitmask(ReflectableBitmask::Values::READ).getValue()), 2); |
1243 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(3, reflectable->size()); |
1244 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(ReflectableBitmask::Values::READ, ReflectableBitmask(reflectable->at(2)->getUInt8())); |
1245 |
|||
1246 |
// out of range |
||
1247 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(reflectable->setAt(AnyHolder<>(ReflectableBitmask::Values::CREATE), 3), CppRuntimeException); |
1248 |
} |
||
1249 |
|||
1250 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, enumeration) |
1251 |
{ |
||
1252 |
1 |
const ReflectableEnum enumeration = ReflectableEnum::VALUE1; |
|
1253 |
✓✗ | 2 |
auto reflectable = enumReflectable(enumeration); |
1254 |
✓✗ | 1 |
checkEnum(enumeration, reflectable); |
1255 |
1 |
} |
|
1256 |
|||
1257 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, enumConstArray) |
1258 |
{ |
||
1259 |
const auto rawArray = std::vector<ReflectableEnum>{{ReflectableEnum::VALUE1, ReflectableEnum::VALUE2, |
||
1260 |
✓✗ | 2 |
ReflectableEnum::VALUE3}}; |
1261 |
✓✗✓✗ |
2 |
auto reflectable = ReflectableFactory::getEnumArray(rawArray); |
1262 |
✓✗✗ | 2 |
checkArray(rawArray, reflectable, |
1263 |
3 |
[&](ReflectableEnum value, const IReflectableConstPtr& elementReflectable) { |
|
1264 |
3 |
checkEnum(value, elementReflectable); |
|
1265 |
3 |
} |
|
1266 |
✓✗ | 1 |
); |
1267 |
|||
1268 |
✓✗ | 2 |
auto nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable); |
1269 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
2 |
ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException); |
1270 |
} |
||
1271 |
|||
1272 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, enumArray) |
1273 |
{ |
||
1274 |
auto rawArray = std::vector<ReflectableEnum>{{ReflectableEnum::VALUE1, ReflectableEnum::VALUE2, |
||
1275 |
✓✗ | 2 |
ReflectableEnum::VALUE3}}; |
1276 |
✓✗✓✗ |
2 |
auto reflectable = ReflectableFactory::getEnumArray(rawArray); |
1277 |
2 |
checkArray(rawArray, reflectable, |
|
1278 |
3 |
[&](ReflectableEnum value, const IReflectablePtr& elementReflectable) { |
|
1279 |
3 |
checkEnum(value, elementReflectable); |
|
1280 |
3 |
} |
|
1281 |
✓✗ | 1 |
); |
1282 |
2 |
checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable), |
|
1283 |
3 |
[&](ReflectableEnum value, const IReflectableConstPtr& elementReflectable) { |
|
1284 |
3 |
checkEnum(value, elementReflectable); |
|
1285 |
3 |
} |
|
1286 |
✓✗ | 1 |
); |
1287 |
|||
1288 |
✓✗ | 1 |
reflectable->resize(0); |
1289 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(0, reflectable->size()); |
1290 |
✓✗✓✗ |
1 |
reflectable->append(AnyHolder<>(ReflectableEnum::VALUE3)); |
1291 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(1, reflectable->size()); |
1292 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(enumToValue(ReflectableEnum::VALUE3), reflectable->at(0)->getInt8()); |
1293 |
✓✗✓✗ |
1 |
reflectable->setAt(AnyHolder<>(ReflectableEnum::VALUE2), 0); |
1294 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(1, reflectable->size()); |
1295 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(enumToValue(ReflectableEnum::VALUE2), reflectable->at(0)->getInt8()); |
1296 |
✓✗ | 1 |
reflectable->resize(2); |
1297 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(2, reflectable->size()); |
1298 |
|||
1299 |
✓✗✓✗ |
1 |
reflectable->append(AnyHolder<>(enumToValue(ReflectableEnum::VALUE1))); |
1300 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(3, reflectable->size()); |
1301 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(enumToValue(ReflectableEnum::VALUE1), reflectable->at(2)->getInt8()); |
1302 |
✓✗✓✗ |
1 |
reflectable->setAt(AnyHolder<>(enumToValue(ReflectableEnum::VALUE2)), 2); |
1303 |
✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(3, reflectable->size()); |
1304 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(enumToValue(ReflectableEnum::VALUE2), reflectable->at(2)->getInt8()); |
1305 |
|||
1306 |
// out of range |
||
1307 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(reflectable->setAt(AnyHolder<>(ReflectableEnum::VALUE2), 3), CppRuntimeException); |
1308 |
} |
||
1309 |
|||
1310 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, compoundConst) |
1311 |
{ |
||
1312 |
{ |
||
1313 |
const ReflectableObject reflectableObjectUninitialized = ReflectableObject{"test", |
||
1314 |
✓✗ | 2 |
ReflectableNested{13}}; |
1315 |
✓✗✓✗ |
2 |
auto reflectable = reflectableObjectUninitialized.reflectable(); |
1316 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ |
1 |
ASSERT_FALSE(reflectable->find("reflectableNested.stringParam")); |
1317 |
} |
||
1318 |
|||
1319 |
✓✗✓✗ |
2 |
const ReflectableObject reflectableObject = createInitializedReflectableObject("test", 13); |
1320 |
✓✗✓✗ ✓✗✗ |
2 |
auto reflectable = reflectableObject.reflectable(); |
1321 |
✓✗ | 1 |
checkCompound(reflectableObject, reflectable); |
1322 |
|||
1323 |
✓✗ | 2 |
IReflectablePtr nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable); |
1324 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
2 |
ASSERT_THROW(nonConstReflectable->initializeChildren(), CppRuntimeException); |
1325 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(nonConstReflectable->initialize(vector<AnyHolder<>>()), CppRuntimeException); |
1326 |
✓✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
1 |
ASSERT_NO_THROW(reflectable->getField("reflectableNested")); |
1327 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(nonConstReflectable->getField("reflectableNested"), CppRuntimeException); |
1328 |
✓✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
1 |
ASSERT_NO_THROW(reflectable->getAnyValue()); |
1329 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
2 |
ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException); |
1330 |
|||
1331 |
✓✗✓✗ |
2 |
IReflectableConstPtr childReflectable = reflectable->getField("reflectableNested"); |
1332 |
✓✗ | 2 |
IReflectablePtr nonConstChildReflectable =std::const_pointer_cast<IReflectable>(childReflectable); |
1333 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(nonConstChildReflectable->setField("value", AnyHolder<>(static_cast<uint32_t>(11))), |
1334 |
CppRuntimeException); |
||
1335 |
✓✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
1 |
ASSERT_NO_THROW(childReflectable->getParameter("dummyParam")); |
1336 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(nonConstChildReflectable->getParameter("dummyParam"), CppRuntimeException); |
1337 |
✓✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
1 |
ASSERT_NO_THROW(childReflectable->callFunction("getValue")); |
1338 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ |
2 |
ASSERT_THROW(nonConstChildReflectable->callFunction("getValue"), CppRuntimeException); |
1339 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
2 |
ASSERT_THROW(nonConstChildReflectable->initializeOffsets(0), CppRuntimeException); |
1340 |
} |
||
1341 |
|||
1342 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, compound) |
1343 |
{ |
||
1344 |
✓✗ | 2 |
ReflectableObject reflectableObject = ReflectableObject{"test", ReflectableNested{13}}; |
1345 |
✓✗✓✗ |
2 |
auto reflectable = reflectableObject.reflectable(); |
1346 |
|||
1347 |
// not initialized |
||
1348 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(reflectable->getField("reflectableNested")->getParameter("dummyParam"), CppRuntimeException); |
1349 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(reflectable->getField("reflectableNested")->getParameter("stringParam"), CppRuntimeException); |
1350 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE(static_cast<IReflectableConstPtr>(reflectable)->find("reflectableNested.stringParam")); |
1351 |
|||
1352 |
✓✗ | 1 |
reflectable->initializeChildren(); |
1353 |
✓✗✓✗ |
1 |
checkCompound(reflectableObject, reflectable); |
1354 |
} |
||
1355 |
|||
1356 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, compoundConstArray) |
1357 |
{ |
||
1358 |
2 |
ReflectableObject reflectableObject1; |
|
1359 |
✓✗✓✗ ✓✗ |
1 |
reflectableObject1 = createInitializedReflectableObject("1", 13); // to cover assignment operator |
1360 |
const auto rawArray = std::vector<ReflectableObject>{{ |
||
1361 |
reflectableObject1, |
||
1362 |
createInitializedReflectableObject("2", 42) |
||
1363 |
✓✗✓✗ ✓✗✓✗ ✓✓✓✗ ✗✗ |
2 |
}}; |
1364 |
✓✗✓✗ |
2 |
auto reflectable = ReflectableFactory::getCompoundArray(rawArray); |
1365 |
✓✗✗ | 2 |
checkArray(rawArray, reflectable, |
1366 |
2 |
[&](const ReflectableObject& value, const IReflectableConstPtr& elementReflectable) { |
|
1367 |
2 |
checkCompound(value, elementReflectable); |
|
1368 |
2 |
} |
|
1369 |
✓✗ | 1 |
); |
1370 |
|||
1371 |
✓✗ | 2 |
IReflectablePtr nonConstReflectable = std::const_pointer_cast<IReflectable>(reflectable); |
1372 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(nonConstReflectable->at(0), CppRuntimeException); |
1373 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW((*nonConstReflectable)[0], CppRuntimeException); |
1374 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
2 |
ASSERT_THROW(nonConstReflectable->resize(nonConstReflectable->size() + 1), CppRuntimeException); |
1375 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(nonConstReflectable->setAt(AnyHolder<>(ReflectableObject{"test", ReflectableNested{0}}), 0), |
1376 |
CppRuntimeException); |
||
1377 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ |
2 |
ASSERT_THROW(nonConstReflectable->append(AnyHolder<>(ReflectableObject{"test", ReflectableNested{0}})), |
1378 |
CppRuntimeException); |
||
1379 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ |
2 |
ASSERT_THROW(nonConstReflectable->getAnyValue(), CppRuntimeException); |
1380 |
} |
||
1381 |
|||
1382 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, compoundArray) |
1383 |
{ |
||
1384 |
auto rawArray = std::vector<ReflectableObject>{{ |
||
1385 |
createInitializedReflectableObject("1", 13), |
||
1386 |
createInitializedReflectableObject("2", 42) |
||
1387 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✓ ✗✗ |
2 |
}}; |
1388 |
✓✗✓✗ |
2 |
auto reflectable = ReflectableFactory::getCompoundArray(rawArray); |
1389 |
2 |
checkArray(rawArray, reflectable, |
|
1390 |
2 |
[&](const ReflectableObject& value, const IReflectablePtr& elementReflectable) { |
|
1391 |
2 |
checkCompound(value, elementReflectable); |
|
1392 |
2 |
} |
|
1393 |
✓✗ | 1 |
); |
1394 |
2 |
checkArray(rawArray, static_cast<IReflectableConstPtr>(reflectable), |
|
1395 |
2 |
[&](const ReflectableObject& value, const IReflectableConstPtr& elementReflectable) { |
|
1396 |
2 |
checkCompound(value, elementReflectable); |
|
1397 |
2 |
} |
|
1398 |
✓✗ | 1 |
); |
1399 |
|||
1400 |
✓✗✓✗ |
1 |
reflectable->resize(reflectable->size() + 1); |
1401 |
✓✗✓✗ ✓✗ |
2 |
IReflectablePtr newCompound = reflectable->at(reflectable->size() - 1); |
1402 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(newCompound); |
1403 |
|||
1404 |
✓✗✓✗ ✓✗ |
1 |
reflectable->setAt(AnyHolder<>(ReflectableObject{"test", ReflectableNested{0}}), 0); |
1405 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(0, reflectable->at(0)->find("reflectableNested.value")->getUInt32()); |
1406 |
✓✗✓✗ ✓✗ |
1 |
reflectable->append(AnyHolder<>(ReflectableObject{"test|", ReflectableNested{1}})); |
1407 |
✓✗✓✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(1, reflectable->at(reflectable->size() - 1)->find("reflectableNested.value")->getUInt32()); |
1408 |
|||
1409 |
✓✗ | 1 |
const size_t size = reflectable->size(); |
1410 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(reflectable->setAt(AnyHolder<>(), size), CppRuntimeException); // out of range |
1411 |
} |
||
1412 |
|||
1413 |
✓✗✓✗ ✓✗✗✓ |
690 |
TEST_F(ReflectableTest, reflectableOwner) |
1414 |
{ |
||
1415 |
✓✗✓✗ ✗✗ |
2 |
auto reflectable = ReflectableObject::typeInfo().createInstance(); |
1416 |
|||
1417 |
// must be as the first one to initialize object |
||
1418 |
✓✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
1 |
ASSERT_NO_THROW(reflectable->initializeChildren()); |
1419 |
|||
1420 |
✓✗ | 2 |
IReflectableConstPtr constReflectable = reflectable; |
1421 |
|||
1422 |
// same as default initialized |
||
1423 |
✓✗ | 2 |
ReflectableObject defaultReflectableObject; |
1424 |
✓✗ | 1 |
defaultReflectableObject.initializeChildren(); |
1425 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(defaultReflectableObject, |
1426 |
reflectable->getAnyValue().template get<std::reference_wrapper<ReflectableObject>>().get()); |
||
1427 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(defaultReflectableObject, |
1428 |
constReflectable->getAnyValue().template get<std::reference_wrapper<ReflectableObject>>().get()); |
||
1429 |
|||
1430 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE(reflectable->isArray()); |
1431 |
✓✗✓✗ |
1 |
reflectable->setField("reflectableNested", AnyHolder<>(ReflectableNested{42})); |
1432 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(42, reflectable->getField("reflectableNested")->getField("value")->getUInt32()); |
1433 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_EQ(42, constReflectable->getField("reflectableNested")->getField("value")->getUInt32()); |
1434 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(reflectable->createField("nonexistent"), CppRuntimeException); |
1435 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(reflectable->getParameter("nonexistent"), CppRuntimeException); |
1436 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(constReflectable->getParameter("nonexistent"), CppRuntimeException); |
1437 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗ |
2 |
ASSERT_THROW(reflectable->callFunction("nonexistent"), CppRuntimeException); |
1438 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓✗✗ |
2 |
ASSERT_THROW(constReflectable->callFunction("nonexistent"), CppRuntimeException); |
1439 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->getChoice(), CppRuntimeException); |
1440 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
2 |
ASSERT_THROW(constReflectable->getChoice(), CppRuntimeException); |
1441 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE(reflectable->find("nonexistent")); |
1442 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE(constReflectable->find("nonexistent")); |
1443 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE((*reflectable)["nonexistent"]); |
1444 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗ |
1 |
ASSERT_FALSE((*constReflectable)["nonexistent"]); |
1445 |
|||
1446 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->size(), CppRuntimeException); // not an array |
1447 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->resize(0), CppRuntimeException); // not an array |
1448 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->at(0), CppRuntimeException); // not an array |
1449 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(constReflectable->at(0), CppRuntimeException); // not an array |
1450 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW((*reflectable)[0], CppRuntimeException); // not an array |
1451 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
2 |
ASSERT_THROW((*constReflectable)[0], CppRuntimeException); // not an array |
1452 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW(reflectable->setAt(AnyHolder<>(), 0), CppRuntimeException); // not an array |
1453 |
✓✗✓✗ ✓✗✓✗ ✗✓✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✗✗ |
2 |
ASSERT_THROW(reflectable->append(AnyHolder<>()), CppRuntimeException); // not an array |
1454 |
|||
1455 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->getBool(), CppRuntimeException); |
1456 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->getInt8(), CppRuntimeException); |
1457 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->getInt16(), CppRuntimeException); |
1458 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->getInt32(), CppRuntimeException); |
1459 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->getInt64(), CppRuntimeException); |
1460 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->getUInt8(), CppRuntimeException); |
1461 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->getUInt16(), CppRuntimeException); |
1462 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->getUInt32(), CppRuntimeException); |
1463 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->getUInt64(), CppRuntimeException); |
1464 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->getFloat(), CppRuntimeException); |
1465 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->getDouble(), CppRuntimeException); |
1466 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->getBytes(), CppRuntimeException); |
1467 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->getStringView(), CppRuntimeException); |
1468 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->getBitBuffer(), CppRuntimeException); |
1469 |
|||
1470 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->toInt(), CppRuntimeException); |
1471 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->toUInt(), CppRuntimeException); |
1472 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✗ ✗ |
2 |
ASSERT_THROW(reflectable->toDouble(), CppRuntimeException); |
1473 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
2 |
ASSERT_THROW(reflectable->toString(), CppRuntimeException); |
1474 |
|||
1475 |
✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✗ |
1 |
ASSERT_EQ(reflectable->bitSizeOf(), reflectable->initializeOffsets()); |
1476 |
|||
1477 |
✓✗✓✗ ✓✗✓✗ ✗✗✗✗ ✗✗✗✗ ✓✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗ |
1 |
ASSERT_NO_THROW(reflectable->initializeChildren()); |
1478 |
|||
1479 |
✓✗ | 1 |
const size_t bitSizeOfValue = reflectable->bitSizeOf(); |
1480 |
✓✗✓✗ |
2 |
BitBuffer bitBuffer(bitSizeOfValue); |
1481 |
✓✗ | 1 |
BitStreamWriter writer(bitBuffer); |
1482 |
✓✗ | 1 |
reflectable->write(writer); |
1483 |
✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗ |
1 |
ASSERT_EQ(bitSizeOfValue, writer.getBitPosition()); |
1484 |
} |
||
1485 |
|||
1486 |
✓✗✓✗ |
2058 |
} // namespace zserio |
| Generated by: GCOVR (Version 4.2) |